
//               File: CiudadDataAdapter
//        Description: Ciudad
//             Author: DeKlarit - Language C# - Generator Version 10_1_3-31907 - Specifier Version 10_1_3.31907
//       Program type: Deklarit Business Component
//          Main DBMS: Microsoft SqlServer

namespace DeklaritModel {
   using System;
   using System.Collections;
   using Deklarit.Utils;
   using System.Data;
   using System.Data.SqlClient;
   using System.Data.Common;
   using Deklarit.Data;
   using System.ComponentModel.Design;
   using System.Runtime.Serialization;
   using System.Security.Permissions;
   using System.Data.SqlTypes;
   public partial class CiudadDataAdapter : System.Data.IDataAdapter, ICiudadDataAdapter
   {
      private CiudadDataSet CiudadSet ;
      private IDbTransaction daCurrentTransaction ;
      private CiudadDataSet.CiudadRow rowCiudad ;
      public CiudadDataAdapter( )
      {
      }

      private void InitializeMembers( )
      {
         CiudadSet = new CiudadDataSet() ;
         this.Initialize( ) ;
         dsDefault = new DataStore( new SqlServer2005Handler( ), "System.Data.SqlClient", DeklaritModel.Configuration.ConnectionString, DeklaritTransaction.TransactionSlotName) ;
      }

      ///  <summary>
      ///   Gets or sets the Transaction object to be used  by  CiudadDataAdapterclasses to commit
      ///    changes to the Database.
      ///  </summary>
      public IDbTransaction Transaction
      {
         get {
            return daCurrentTransaction ;
         }

         set {
            daCurrentTransaction = value ;
         }

      }

      ///  <summary>
      ///   Gets or sets the missing mapping action.
      ///  </summary>
      public MissingMappingAction MissingMappingAction
      {
         get {
            return System.Data.MissingMappingAction.Passthrough ;
         }

         set {
         }

      }

      ///  <summary>
      ///   Gets or sets the missing schema action.
      ///  </summary>
      public MissingSchemaAction MissingSchemaAction
      {
         get {
            return System.Data.MissingSchemaAction.Ignore ;
         }

         set {
         }

      }

      ///  <summary>
      ///   Gets the table mappings.
      ///  </summary>
      public ITableMappingCollection TableMappings
      {
         get {
            System.Data.Common.DataTableMappingCollection tableMaps ;
            tableMaps = new System.Data.Common.DataTableMappingCollection() ;
            return tableMaps ;
         }

      }

      ///  <summary>
      ///   Fills the schema for the datasource.
      ///  </summary>
      ///  <param name="dataSet">DataSet</param>
      ///  <param name="schemaType">Schema type</param>
      public virtual DataTable[] FillSchema( DataSet dataSet ,
                                             SchemaType schemaType )
      {
         DataTable[] dataTables ;
         dataTables = new DataTable[dataSet.Tables.Count]  ;
         dataSet.Tables.CopyTo( dataTables, dataSet.Tables.Count) ;
         return dataTables ;
      }


      ///  <summary>
      ///   (2) Fills the specified Dataset with the record matching PaisId, CiudadId field(s)
      ///    of the given IDataRecord
      ///  </summary>
      ///  <param name="dataSet">DataSet</param>
      ///  <param name="dataRecord">Data Record</param>
      public virtual int Fill( CiudadDataSet dataSet ,
                               IDataRecord dataRecord )
      {
         return Fill(dataSet, ((short)(dataRecord["PaisId"])), ((short)(dataRecord["CiudadId"]))) ;
      }

      ///  <summary>
      ///   (3) Fills the specified Dataset with the record matching PaisId, CiudadId field(s)
      ///    of the given DataRow
      ///  </summary>
      ///  <param name="dataSet">DataSet</param>
      ///  <param name="dataRecord">Data Row</param>
      public virtual int Fill( CiudadDataSet dataSet ,
                               DataRow dataRecord )
      {
         return Fill(dataSet, ((short)(dataRecord["PaisId"])), ((short)(dataRecord["CiudadId"]))) ;
      }

      ///  <summary>
      ///   (4) Fills the specified Dataset with the record matching PaisId, CiudadId, if the
      ///    record is not found , throws an exception.
      ///  </summary>
      ///  <param name="dataSet">DataSet</param>
      ///  <param name="paisId">Id Pais</param>
      ///  <param name="ciudadId">Id</param>
      public virtual int Fill( CiudadDataSet dataSet ,
                               short paisId ,
                               short ciudadId )
      {
         if ( ! FillByPaisIdCiudadId( dataSet, paisId, ciudadId) )
         {
            throw new CiudadNotFoundException( string.Format(resourceManager.GetString("GXM_inex"), new   object[]  {"Ciudad"})) ;
         }
         return 0 ;
      }


      ///  <summary>
      ///   (5) Fills the specified Dataset with the record matching PaisId, CiudadId in the
      ///    fillDataParameters array, if the array is null, it fills the Dataset loading all
      ///    records in the table.
      ///  </summary>
      ///  <param name="dataSet">DataSet</param>
      public virtual int Fill( CiudadDataSet dataSet )
      {
         if ( fillDataParameters != null )
         {
            Fill( dataSet, System.Int16.Parse( fillDataParameters[0].Value.ToString()), System.Int16.Parse( fillDataParameters[1].Value.ToString())) ;
         }
         else
         {
            try
            {
               InitializeMembers( ) ;
               connDefault = dsDefault.GetReadWriteConnection( daCurrentTransaction) ;
               CiudadSet = dataSet ;
               LoadChildCiudad( 0, -1) ;
               dataSet.AcceptChanges( ) ;
            }
            finally
            {
               this.Cleanup();
            }
         }
         return 0 ;
      }


      ///  <summary>
      ///   (6) Fills the specified dataset filtered by PaisId, CiudadIdfield(s).
      ///  </summary>
      ///  <param name="dataSet">DataSet</param>
      ///  <param name="paisId">Id Pais</param>
      ///  <param name="ciudadId">Id</param>
      public virtual bool FillByPaisIdCiudadId( CiudadDataSet dataSet ,
                                                short paisId ,
                                                short ciudadId )
      {
         InitializeMembers( ) ;
         connDefault = dsDefault.GetReadWriteConnection( daCurrentTransaction) ;
         CiudadSet = dataSet ;
         rowCiudad = CiudadSet.Ciudad.NewCiudadRow() ;
         rowCiudad.PaisId = paisId ;
         rowCiudad.CiudadId = ciudadId ;
         try
         {
            LoadByPaisIdCiudadId( 0, -1) ;
            dataSet.AcceptChanges( ) ;
         }
         finally
         {
            this.Cleanup();
         }
         if ( RcdFound6 == 0 )
         {
            return false ;
         }
         return true ;
      }


      ///  <summary>
      ///   (6) Fills the specified dataset filtered by PaisIdfield(s).
      ///  </summary>
      ///  <param name="dataSet">DataSet</param>
      ///  <param name="paisId">Id Pais</param>
      public virtual int FillByPaisId( CiudadDataSet dataSet ,
                                       short paisId )
      {
         InitializeMembers( ) ;
         connDefault = dsDefault.GetReadWriteConnection( daCurrentTransaction) ;
         CiudadSet = dataSet ;
         rowCiudad = CiudadSet.Ciudad.NewCiudadRow() ;
         rowCiudad.PaisId = paisId ;
         try
         {
            LoadByPaisId( 0, -1) ;
            dataSet.AcceptChanges( ) ;
         }
         finally
         {
            this.Cleanup();
         }
         return 0 ;
      }


      ///  <summary>
      ///   (6) Fills a page of up to maxRows rows into the specified dataset filtered by PaisIdfield(s)starting
      ///    at startRow
      ///  </summary>
      ///  <param name="dataSet">DataSet</param>
      ///  <param name="paisId">Id Pais</param>
      ///  <param name="startRow">Starting row</param>
      ///  <param name="maxRows">Max number of rows to load</param>
      public virtual int FillPageByPaisId( CiudadDataSet dataSet ,
                                           short paisId ,
                                           int startRow ,
                                           int maxRows )
      {
         InitializeMembers( ) ;
         connDefault = dsDefault.GetReadWriteConnection( daCurrentTransaction) ;
         CiudadSet = dataSet ;
         rowCiudad = CiudadSet.Ciudad.NewCiudadRow() ;
         rowCiudad.PaisId = paisId ;
         try
         {
            LoadByPaisId( startRow, maxRows) ;
            dataSet.AcceptChanges( ) ;
         }
         finally
         {
            this.Cleanup();
         }
         return 0 ;
      }


      ///  <summary>
      ///   (9) Gets the record count filtered by PaisIdfield(s).
      ///  </summary>
      ///  <param name="paisId">Id Pais</param>
      public virtual int GetRecordCountByPaisId( short paisId )
      {
         int m_Count ;
         try
         {
            InitializeMembers( ) ;
            m_Count = GetInternalRecordCountByPaisId( paisId ) ;
         }
         finally
         {
            this.Cleanup();
         }
         return m_Count ;
      }

      private int GetInternalRecordCountByPaisId( short paisId )
      {
         connDefault = dsDefault.GetReadWriteConnection( daCurrentTransaction) ;
         cmCIUDADSELECT1 = connDefault.GetCommand("SELECT COUNT(*) FROM [Ciudad] WITH (NOLOCK) WHERE [PaisId] = @PaisId ", false) ;
         if ( cmCIUDADSELECT1.IDbCommand.Parameters.Count == 0 )
         {
            cmCIUDADSELECT1.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@PaisId", System.Data.DbType.Int16));
         }
         cmCIUDADSELECT1.SetParameter(0, paisId);
         CIUDADSELECT1 = cmCIUDADSELECT1.FetchData() ;
         recordCount = ( ( CIUDADSELECT1.IsDBNull(0) )  ? (int)(0) : CIUDADSELECT1.GetInt32(0) ) ;
         CIUDADSELECT1.Close();
         return recordCount ;
      }

      ///  <summary>
      ///   (8) Fills the specified dataset with the record matching PaisId, CiudadId in the
      ///    the fillDataParameters array, if the array is null, it fills the Dataset loading
      ///    all records in the table.
      ///  </summary>
      ///  <param name="dataSet">DataSet</param>
      public virtual int Fill( DataSet dataSet )
      {
         CiudadSet = dataSet as CiudadDataSet ;
         if ( CiudadSet != null )
         {
            return Fill( CiudadSet) ;
         }
         else
         {
            CiudadSet = new CiudadDataSet() ;
            Fill( CiudadSet) ;
            dataSet.Merge( CiudadSet) ;
            return 0 ;
         }
      }

      ///  <summary>
      ///   (11) Fills a page of up to maxRows rows into the specified dataset starting at startRow
      ///
      ///  </summary>
      ///  <param name="dataSet">DataSet</param>
      ///  <param name="startRow">Starting row</param>
      ///  <param name="maxRows">Max number of rows to load</param>
      public virtual int FillPage( CiudadDataSet dataSet ,
                                   int startRow ,
                                   int maxRows )
      {
         InitializeMembers( ) ;
         connDefault = dsDefault.GetReadWriteConnection( daCurrentTransaction) ;
         CiudadSet = dataSet ;
         try
         {
            LoadChildCiudad( startRow, maxRows) ;
            dataSet.AcceptChanges( ) ;
         }
         finally
         {
            this.Cleanup();
         }
         return 0 ;
      }


      ///  <summary>
      ///   (9) Gets the total record count.
      ///  </summary>
      public virtual int GetRecordCount( )
      {
         int m_Count ;
         try
         {
            InitializeMembers( ) ;
            m_Count = GetInternalRecordCount(  ) ;
         }
         finally
         {
            this.Cleanup();
         }
         return m_Count ;
      }

      private int GetInternalRecordCount( )
      {
         connDefault = dsDefault.GetReadWriteConnection( daCurrentTransaction) ;
         cmCIUDADSELECT2 = connDefault.GetCommand("SELECT COUNT(*) FROM [Ciudad] WITH (NOLOCK) ", false) ;
         CIUDADSELECT2 = cmCIUDADSELECT2.FetchData() ;
         recordCount = ( ( CIUDADSELECT2.IsDBNull(0) )  ? (int)(0) : CIUDADSELECT2.GetInt32(0) ) ;
         CIUDADSELECT2.Close();
         return recordCount ;
      }

      ///  <summary>
      ///   Gets the fill parameters array.
      ///  </summary>
      public virtual IDataParameter[] GetFillParameters( )
      {
         if ( fillDataParameters == null )
         {
            DbProviderFactory factory = System.Data.Common.DbProviderFactories.GetFactory( "System.Data.SqlClient") ;
            DbParameter parm0PaisId ;
            parm0PaisId = factory.CreateParameter() ;
            parm0PaisId.ParameterName = "PaisId" ;
            parm0PaisId.DbType = System.Data.DbType.Int16 ;
            DbParameter parm1CiudadId ;
            parm1CiudadId = factory.CreateParameter() ;
            parm1CiudadId.ParameterName = "CiudadId" ;
            parm1CiudadId.DbType = System.Data.DbType.Int16 ;
            fillDataParameters = new  DbParameter[]  {parm0PaisId, parm1CiudadId} ;
         }
         return fillDataParameters ;
      }

      private DbParameter[] fillDataParameters ;

      ///  <summary>
      ///   Inserts, Updates or Deletes records from the specified CiudadDataSet object.
      ///  </summary>
      ///  <param name="dataSet">DataSet</param>
      public virtual int Update( DataSet dataSet )
      {
         InitializeMembers( ) ;
         CiudadSet = dataSet as CiudadDataSet ;
         connDefault = dsDefault.GetReadWriteConnection( daCurrentTransaction) ;
         if ( CiudadSet != null )
         {
            try
            {
               connDefault.BeginTransaction();
               foreach( CiudadDataSet.CiudadRow row in CiudadSet.Ciudad )
               {
                  rowCiudad = row ;
                  if ( Deklarit.Data.Helpers.IsRowChanged(rowCiudad) )
                  {
                     ReadRowCiudad( ) ;
                     if ( rowCiudad.RowState == System.Data.DataRowState.Added )
                     {
                        InsertCiudad( ) ;
                     }
                     else
                     {
                        if ( _Gxremove )
                        {
                           Delete( ) ;
                        }
                        else
                        {
                           UpdateCiudad( ) ;
                        }
                     }
                  }
               }

               dataSet.AcceptChanges( ) ;
               connDefault.Commit();
            }
            catch ( Exception  )
            {
               connDefault.Rollback();
               throw  ;
            }
            finally
            {
               this.Cleanup();
            }
         }
         else
         {
            throw new System.ArgumentException( string.Format(resourceManager.GetString("GXM_nulldset"), new   object[]  {})) ;
         }
         return 0 ;
      }

      private void LoadRowCiudad( )
      {
         AddRowCiudad( ) ;
      }

      private void ReadRowCiudad( )
      {
         Gx_mode = Deklarit.Utils.Mode.FromRowState(rowCiudad.RowState) ;
         if ( rowCiudad.RowState != System.Data.DataRowState.Added )
         {
            m__CiudadNombreOriginal = rowCiudad["CiudadNombre", System.Data.DataRowVersion.Original] ;
         }
         else
         {
            m__CiudadNombreOriginal = rowCiudad["CiudadNombre"] ;
         }
         _Gxremove = (bool)((rowCiudad.RowState==System.Data.DataRowState.Deleted)) ;
         if ( _Gxremove )
         {
            rowCiudad = ((CiudadDataSet.CiudadRow)(Deklarit.Utils.DataSetUtil.CloneOriginalDataRow(rowCiudad)));
         }
      }

      private void LoadCiudad( )
      {
          IDataReader PAISSELECT1 ;
          ReadWriteCommand cmPAISSELECT1 ;
         cmPAISSELECT1 = connDefault.GetCommand("SELECT [PaisNombre], [PaisMoneda] FROM [Pais] WITH (NOLOCK) WHERE [PaisId] = @PaisId ", false) ;
         if ( cmPAISSELECT1.IDbCommand.Parameters.Count == 0 )
         {
            cmPAISSELECT1.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@PaisId", System.Data.DbType.Int16));
         }
         cmPAISSELECT1.SetParameter(0, rowCiudad["PaisId"]);
         PAISSELECT1 = cmPAISSELECT1.FetchData() ;
         if ( cmPAISSELECT1.HasMoreRows )
         {
            rowCiudad["PaisNombre"] = dsDefault.Db.GetString(PAISSELECT1, 0) ;
            rowCiudad["PaisMoneda"] = dsDefault.Db.GetString(PAISSELECT1, 1) ;
         }
         PAISSELECT1.Close();
      }

      private void CheckExtendedTableCiudad( )
      {
          IDataReader PAISSELECT2 ;
          ReadWriteCommand cmPAISSELECT2 ;
         cmPAISSELECT2 = connDefault.GetCommand("SELECT [PaisNombre], [PaisMoneda] FROM [Pais] WITH (NOLOCK) WHERE [PaisId] = @PaisId ", false) ;
         if ( cmPAISSELECT2.IDbCommand.Parameters.Count == 0 )
         {
            cmPAISSELECT2.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@PaisId", System.Data.DbType.Int16));
         }
         cmPAISSELECT2.SetParameter(0, rowCiudad["PaisId"]);
         PAISSELECT2 = cmPAISSELECT2.FetchData() ;
         if ( !cmPAISSELECT2.HasMoreRows )
         {
            PAISSELECT2.Close();
            throw new PaisForeignKeyNotFoundException( string.Format(resourceManager.GetString("GXM_inex"), new   object[]  {"Pais"})) ;
         }
         rowCiudad["PaisNombre"] = dsDefault.Db.GetString(PAISSELECT2, 0) ;
         rowCiudad["PaisMoneda"] = dsDefault.Db.GetString(PAISSELECT2, 1) ;
         PAISSELECT2.Close();
      }

      private void GetByPrimaryKey( )
      {
          IDataReader CIUDADSELECT3 ;
          ReadWriteCommand cmCIUDADSELECT3 ;
         cmCIUDADSELECT3 = connDefault.GetCommand("SELECT [CiudadId], [CiudadNombre], [PaisId] FROM [Ciudad] WITH (NOLOCK) WHERE [PaisId] = @PaisId AND [CiudadId] = @CiudadId ", false) ;
         if ( cmCIUDADSELECT3.IDbCommand.Parameters.Count == 0 )
         {
            cmCIUDADSELECT3.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@PaisId", System.Data.DbType.Int16));
            cmCIUDADSELECT3.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@CiudadId", System.Data.DbType.Int16));
         }
         cmCIUDADSELECT3.SetParameter(0, rowCiudad["PaisId"]);
         cmCIUDADSELECT3.SetParameter(1, rowCiudad["CiudadId"]);
         CIUDADSELECT3 = cmCIUDADSELECT3.FetchData() ;
         if ( cmCIUDADSELECT3.HasMoreRows )
         {
            RcdFound6 = 1 ;
            rowCiudad["CiudadId"] = dsDefault.Db.GetInt16(CIUDADSELECT3, 0) ;
            rowCiudad["CiudadNombre"] = dsDefault.Db.GetString(CIUDADSELECT3, 1) ;
            rowCiudad["PaisId"] = dsDefault.Db.GetInt16(CIUDADSELECT3, 2) ;
            sMode6 = Gx_mode ;
            Gx_mode = Mode.Display ;
            LoadCiudad( ) ;
            Gx_mode = sMode6 ;
         }
         else
         {
            RcdFound6 = 0 ;
         }
         CIUDADSELECT3.Close();
      }

      private void CheckOptimisticConcurrencyCiudad( )
      {
          ReadWriteCommand cmCIUDADSELECT4 ;
         if ( Gx_mode != Mode.Insert )
         {
            cmCIUDADSELECT4 = connDefault.GetCommand("SELECT [CiudadId], [CiudadNombre], [PaisId] FROM [Ciudad] WITH (UPDLOCK) WHERE [PaisId] = @PaisId AND [CiudadId] = @CiudadId ", false) ;
            if ( cmCIUDADSELECT4.IDbCommand.Parameters.Count == 0 )
            {
               cmCIUDADSELECT4.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@PaisId", System.Data.DbType.Int16));
               cmCIUDADSELECT4.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@CiudadId", System.Data.DbType.Int16));
            }
            cmCIUDADSELECT4.SetParameter(0, rowCiudad["PaisId"]);
            cmCIUDADSELECT4.SetParameter(1, rowCiudad["CiudadId"]);
            CIUDADSELECT4 = cmCIUDADSELECT4.FetchData() ;
            if ( cmCIUDADSELECT4.Locked )
            {
               CIUDADSELECT4.Close();
               throw new CiudadDataLockedException( string.Format(resourceManager.GetString("GXM_lock"), new   object[]  {"Ciudad"})) ;
            }
            if ( !cmCIUDADSELECT4.HasMoreRows || ( ! StringUtil.ObjectStringEquals(m__CiudadNombreOriginal,dsDefault.Db.GetString(CIUDADSELECT4, 1)) ) )
            {
               CIUDADSELECT4.Close();
               throw new CiudadDataChangedException( string.Format(resourceManager.GetString("GXM_waschg"), new   object[]  {"Ciudad"})) ;
            }
            CIUDADSELECT4.Close();
         }
      }

      private void InsertCiudad( )
      {
          ReadWriteCommand cmCIUDADINSERT1 ;
         CheckExtendedTableCiudad( ) ;
         CheckOptimisticConcurrencyCiudad( ) ;
         AfterConfirmCiudad( ) ;
         cmCIUDADINSERT1 = connDefault.GetCommand("INSERT INTO [Ciudad] ([CiudadId], [CiudadNombre], [PaisId]) VALUES (@CiudadId, @CiudadNombre, @PaisId)", false) ;
         if ( cmCIUDADINSERT1.IDbCommand.Parameters.Count == 0 )
         {
            cmCIUDADINSERT1.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@CiudadId", System.Data.DbType.Int16));
            cmCIUDADINSERT1.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@CiudadNombre", System.Data.DbType.AnsiStringFixedLength,20));
            cmCIUDADINSERT1.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@PaisId", System.Data.DbType.Int16));
         }
         cmCIUDADINSERT1.ErrorMask = cmCIUDADINSERT1.ErrorMask  |  ErrorMask.DuplicateKeyError;
         // Using cursor CIUDADINSERT1
         cmCIUDADINSERT1.SetParameter(0, rowCiudad["CiudadId"]);
         cmCIUDADINSERT1.SetParameter(1, rowCiudad["CiudadNombre"]);
         cmCIUDADINSERT1.SetParameter(2, rowCiudad["PaisId"]);
         cmCIUDADINSERT1.ExecuteStmt();
         if ( cmCIUDADINSERT1.DupKey )
         {
            throw new CiudadDuplicateKeyException( string.Format(resourceManager.GetString("GXM_noupdate"), new   object[]  {})) ;
         }
         // Start of After( Insert) rules
         // End of After( Insert) rules
         OnCiudadUpdated( new CiudadEventArgs( rowCiudad, Mode.Insert)) ;
         // Save values for previous() function.
         EndLevelCiudad( ) ;
      }

      private void UpdateCiudad( )
      {
          ReadWriteCommand cmCIUDADUPDATE1 ;
         CheckExtendedTableCiudad( ) ;
         CheckOptimisticConcurrencyCiudad( ) ;
         AfterConfirmCiudad( ) ;
         cmCIUDADUPDATE1 = connDefault.GetCommand("UPDATE [Ciudad] SET [CiudadNombre]=@CiudadNombre  WHERE [PaisId] = @PaisId AND [CiudadId] = @CiudadId", false) ;
         if ( cmCIUDADUPDATE1.IDbCommand.Parameters.Count == 0 )
         {
            cmCIUDADUPDATE1.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@CiudadNombre", System.Data.DbType.AnsiStringFixedLength,20));
            cmCIUDADUPDATE1.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@PaisId", System.Data.DbType.Int16));
            cmCIUDADUPDATE1.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@CiudadId", System.Data.DbType.Int16));
         }
         // Using cursor CIUDADUPDATE1
         cmCIUDADUPDATE1.SetParameter(0, rowCiudad["CiudadNombre"]);
         cmCIUDADUPDATE1.SetParameter(1, rowCiudad["PaisId"]);
         cmCIUDADUPDATE1.SetParameter(2, rowCiudad["CiudadId"]);
         cmCIUDADUPDATE1.ExecuteStmt();
         if ( cmCIUDADUPDATE1.Locked )
         {
            CIUDADSELECT4.Close();
            throw new CiudadDataLockedException( string.Format(resourceManager.GetString("GXM_lock"), new   object[]  {"Ciudad"})) ;
         }
         // Start of After( update) rules
         // End of After( update) rules
         OnCiudadUpdated( new CiudadEventArgs( rowCiudad, Mode.Update)) ;
         EndLevelCiudad( ) ;
      }

      private void Delete( )
      {
          ReadWriteCommand cmCIUDADDELETE1 ;
         Gx_mode = Mode.Delete ;
         CheckOptimisticConcurrencyCiudad( ) ;
         OnDeleteControlsCiudad( ) ;
         AfterConfirmCiudad( ) ;
         // No cascading delete specified.
         cmCIUDADDELETE1 = connDefault.GetCommand("DELETE FROM [Ciudad]  WHERE [PaisId] = @PaisId AND [CiudadId] = @CiudadId", false) ;
         if ( cmCIUDADDELETE1.IDbCommand.Parameters.Count == 0 )
         {
            cmCIUDADDELETE1.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@PaisId", System.Data.DbType.Int16));
            cmCIUDADDELETE1.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@CiudadId", System.Data.DbType.Int16));
         }
         cmCIUDADDELETE1.ErrorMask = cmCIUDADDELETE1.ErrorMask  |  ErrorMask.ForeignKeyError;
         // Using cursor CIUDADDELETE1
         cmCIUDADDELETE1.SetParameter(0, rowCiudad["PaisId"]);
         cmCIUDADDELETE1.SetParameter(1, rowCiudad["CiudadId"]);
         cmCIUDADDELETE1.ExecuteStmt();
         // Start of After( delete) rules
         // End of After( delete) rules
         OnCiudadUpdated( new CiudadEventArgs( rowCiudad, Mode.Delete)) ;
         rowCiudad.Delete( ) ;
         sMode6 = Gx_mode ;
         Gx_mode = Mode.Delete ;
         EndLevelCiudad( ) ;
         Gx_mode = sMode6 ;
      }

      private void OnDeleteControlsCiudad( )
      {
          IDataReader PAISSELECT3 ;
          ReadWriteCommand cmPAISSELECT3 ;
         // Delete mode formulas
         cmPAISSELECT3 = connDefault.GetCommand("SELECT [PaisNombre], [PaisMoneda] FROM [Pais] WITH (NOLOCK) WHERE [PaisId] = @PaisId ", false) ;
         if ( cmPAISSELECT3.IDbCommand.Parameters.Count == 0 )
         {
            cmPAISSELECT3.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@PaisId", System.Data.DbType.Int16));
         }
         cmPAISSELECT3.SetParameter(0, rowCiudad["PaisId"]);
         PAISSELECT3 = cmPAISSELECT3.FetchData() ;
         if ( cmPAISSELECT3.HasMoreRows )
         {
            rowCiudad["PaisNombre"] = dsDefault.Db.GetString(PAISSELECT3, 0) ;
            rowCiudad["PaisMoneda"] = dsDefault.Db.GetString(PAISSELECT3, 1) ;
         }
         PAISSELECT3.Close();
      }

      private void EndLevelCiudad( )
      {
         // Execute 'After Trn' event if defined.
         IsModified = 0 ;
      }

      private void ScanByPaisIdCiudadId( int startRow ,
                                         int maxRows )
      {
         m_WhereString = " WHERE TM1.[PaisId] = @PaisId and TM1.[CiudadId] = @CiudadId" ;
         if ( maxRows >= 0 )
         {
            if ( startRow == 0 )
            {
               scmdbuf = "SELECT TOP " + maxRows.ToString() + "  " + m_SelectString6 + "  FROM ([Ciudad] TM1 WITH (NOLOCK) INNER JOIN [Pais] T2 WITH (NOLOCK) ON T2.[PaisId] = TM1.[PaisId])" + m_WhereString + " ORDER BY TM1.[PaisId], TM1.[CiudadId]" ;
            }
            else
            {
               scmdbuf = " SELECT * FROM ( SELECT  " + m_SelectString6 + ", ROW_NUMBER() OVER  (  ORDER BY TM1.[PaisId], TM1.[CiudadId] ) AS DK_PAGENUM   FROM ([Ciudad] TM1 WITH (NOLOCK) INNER JOIN [Pais] T2 WITH (NOLOCK) ON T2.[PaisId] = TM1.[PaisId]) " + m_WhereString + " ) AS DK_PAGE WHERE DK_PAGENUM BETWEEN " + (startRow + 1).ToString() + " AND " + (startRow + maxRows).ToString() ;
            }
         }
         else
         {
            scmdbuf = "SELECT " + m_SelectString6 + " FROM ([Ciudad] TM1 WITH (NOLOCK) INNER JOIN [Pais] T2 WITH (NOLOCK) ON T2.[PaisId] = TM1.[PaisId])" + m_WhereString + " ORDER BY TM1.[PaisId], TM1.[CiudadId] " ;
         }
         cmCIUDADSELECT5 = connDefault.GetCommand(scmdbuf, false) ;
         if ( cmCIUDADSELECT5.IDbCommand.Parameters.Count == 0 )
         {
            cmCIUDADSELECT5.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@PaisId", System.Data.DbType.Int16));
            cmCIUDADSELECT5.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@CiudadId", System.Data.DbType.Int16));
         }
         cmCIUDADSELECT5.SetParameter(0, rowCiudad["PaisId"]);
         cmCIUDADSELECT5.SetParameter(1, rowCiudad["CiudadId"]);
         CIUDADSELECT5 = cmCIUDADSELECT5.FetchData() ;
         RcdFound6 = 0 ;
         ScanKeyLoadCiudad( ) ;
         LoadKeyDataCiudad( maxRows) ;
         // Load Subordinate Levels
      }

      private void ScanByPaisId( int startRow ,
                                 int maxRows )
      {
         m_WhereString = " WHERE TM1.[PaisId] = @PaisId" ;
         if ( maxRows >= 0 )
         {
            if ( startRow == 0 )
            {
               scmdbuf = "SELECT TOP " + maxRows.ToString() + "  " + m_SelectString6 + "  FROM ([Ciudad] TM1 WITH (NOLOCK) INNER JOIN [Pais] T2 WITH (NOLOCK) ON T2.[PaisId] = TM1.[PaisId])" + m_WhereString + " ORDER BY TM1.[PaisId], TM1.[CiudadId]" ;
            }
            else
            {
               scmdbuf = " SELECT * FROM ( SELECT  " + m_SelectString6 + ", ROW_NUMBER() OVER  (  ORDER BY TM1.[PaisId], TM1.[CiudadId] ) AS DK_PAGENUM   FROM ([Ciudad] TM1 WITH (NOLOCK) INNER JOIN [Pais] T2 WITH (NOLOCK) ON T2.[PaisId] = TM1.[PaisId]) " + m_WhereString + " ) AS DK_PAGE WHERE DK_PAGENUM BETWEEN " + (startRow + 1).ToString() + " AND " + (startRow + maxRows).ToString() ;
            }
         }
         else
         {
            scmdbuf = "SELECT " + m_SelectString6 + " FROM ([Ciudad] TM1 WITH (NOLOCK) INNER JOIN [Pais] T2 WITH (NOLOCK) ON T2.[PaisId] = TM1.[PaisId])" + m_WhereString + " ORDER BY TM1.[PaisId], TM1.[CiudadId] " ;
         }
         cmCIUDADSELECT5 = connDefault.GetCommand(scmdbuf, false) ;
         if ( cmCIUDADSELECT5.IDbCommand.Parameters.Count == 0 )
         {
            cmCIUDADSELECT5.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@PaisId", System.Data.DbType.Int16));
         }
         cmCIUDADSELECT5.SetParameter(0, rowCiudad["PaisId"]);
         CIUDADSELECT5 = cmCIUDADSELECT5.FetchData() ;
         RcdFound6 = 0 ;
         ScanKeyLoadCiudad( ) ;
         LoadKeyDataCiudad( maxRows) ;
         // Load Subordinate Levels
      }

      private void ScanKeyStartCiudad( int startRow ,
                                       int maxRows )
      {
         m_WhereString = "" ;
         if ( maxRows >= 0 )
         {
            if ( startRow == 0 )
            {
               scmdbuf = "SELECT TOP " + maxRows.ToString() + "  " + m_SelectString6 + "  FROM ([Ciudad] TM1 WITH (NOLOCK) INNER JOIN [Pais] T2 WITH (NOLOCK) ON T2.[PaisId] = TM1.[PaisId])" + m_WhereString + " ORDER BY TM1.[PaisId], TM1.[CiudadId]" ;
            }
            else
            {
               scmdbuf = " SELECT * FROM ( SELECT  " + m_SelectString6 + ", ROW_NUMBER() OVER  (  ORDER BY TM1.[PaisId], TM1.[CiudadId] ) AS DK_PAGENUM   FROM ([Ciudad] TM1 WITH (NOLOCK) INNER JOIN [Pais] T2 WITH (NOLOCK) ON T2.[PaisId] = TM1.[PaisId]) " + m_WhereString + " ) AS DK_PAGE WHERE DK_PAGENUM BETWEEN " + (startRow + 1).ToString() + " AND " + (startRow + maxRows).ToString() ;
            }
         }
         else
         {
            scmdbuf = "SELECT " + m_SelectString6 + " FROM ([Ciudad] TM1 WITH (NOLOCK) INNER JOIN [Pais] T2 WITH (NOLOCK) ON T2.[PaisId] = TM1.[PaisId])" + m_WhereString + " ORDER BY TM1.[PaisId], TM1.[CiudadId] " ;
         }
         cmCIUDADSELECT5 = connDefault.GetCommand(scmdbuf, false) ;
         CIUDADSELECT5 = cmCIUDADSELECT5.FetchData() ;
         RcdFound6 = 0 ;
         ScanKeyLoadCiudad( ) ;
         LoadKeyDataCiudad( maxRows) ;
         // Load Subordinate Levels
      }

      private void ScanKeyNextCiudad( )
      {
         cmCIUDADSELECT5.HasMoreRows = CIUDADSELECT5.Read() ;
         RcdFound6 = 0 ;
         ScanKeyLoadCiudad( ) ;
      }

      private void ScanKeyLoadCiudad( )
      {
         sMode6 = Gx_mode ;
         Gx_mode = Mode.Display ;
         if ( cmCIUDADSELECT5.HasMoreRows )
         {
            RcdFound6 = 1 ;
            rowCiudad["CiudadId"] = dsDefault.Db.GetInt16(CIUDADSELECT5, 0) ;
            rowCiudad["PaisNombre"] = dsDefault.Db.GetString(CIUDADSELECT5, 1) ;
            rowCiudad["PaisMoneda"] = dsDefault.Db.GetString(CIUDADSELECT5, 2) ;
            rowCiudad["CiudadNombre"] = dsDefault.Db.GetString(CIUDADSELECT5, 3) ;
            rowCiudad["PaisId"] = dsDefault.Db.GetInt16(CIUDADSELECT5, 4) ;
            rowCiudad["PaisNombre"] = dsDefault.Db.GetString(CIUDADSELECT5, 1) ;
            rowCiudad["PaisMoneda"] = dsDefault.Db.GetString(CIUDADSELECT5, 2) ;
         }
         Gx_mode = sMode6 ;
      }

      private void ScanKeyEndCiudad( )
      {
         CIUDADSELECT5.Close();
      }

      private void AfterConfirmCiudad( )
      {
         // After Confirm Rules
         OnCiudadUpdating( new CiudadEventArgs( rowCiudad, Gx_mode)) ;
      }

      private void CreateNewRowCiudad( )
      {
         rowCiudad = CiudadSet.Ciudad.NewCiudadRow() ;
      }

      private void LoadChildCiudad( int startRow ,
                                    int maxRows )
      {
         CreateNewRowCiudad( ) ;
         bool tmpConstraintState = CiudadSet.EnforceConstraints ;
         CiudadSet.Ciudad.BeginLoadData( ) ;
         ScanKeyStartCiudad( startRow, maxRows) ;
         CiudadSet.Ciudad.EndLoadData( ) ;
         this.CiudadSet.EnforceConstraints = tmpConstraintState ;
      }

      private void LoadKeyDataCiudad( int maxRows )
      {
         int loadedRows = 0 ;
         if ( RcdFound6 != 0 )
         {
            ScanKeyLoadCiudad( ) ;
            while ( ( RcdFound6 != 0 ) && ( loadedRows != maxRows ) )
            {
               loadedRows++ ;
               LoadRowCiudad( ) ;
               CreateNewRowCiudad( ) ;
               ScanKeyNextCiudad( ) ;
            }
         }
         if ( loadedRows > 0 )
         {
            RcdFound6 = 1 ;
         }
         ScanKeyEndCiudad( ) ;
         if ( CiudadSet.Ciudad.Count > 0 )
         {
            rowCiudad = CiudadSet.Ciudad[CiudadSet.Ciudad.Count -1] ;
         }
      }

      private void LoadByPaisIdCiudadId( int startRow ,
                                         int maxRows )
      {
         bool tmpConstraintState = CiudadSet.EnforceConstraints ;
         CiudadSet.Ciudad.BeginLoadData( ) ;
         ScanByPaisIdCiudadId( startRow, maxRows) ;
         CiudadSet.Ciudad.EndLoadData( ) ;
         this.CiudadSet.EnforceConstraints = tmpConstraintState ;
         if ( CiudadSet.Ciudad.Count > 0 )
         {
            rowCiudad = CiudadSet.Ciudad[CiudadSet.Ciudad.Count -1] ;
         }
      }

      private void LoadByPaisId( int startRow ,
                                 int maxRows )
      {
         bool tmpConstraintState = CiudadSet.EnforceConstraints ;
         CiudadSet.Ciudad.BeginLoadData( ) ;
         ScanByPaisId( startRow, maxRows) ;
         CiudadSet.Ciudad.EndLoadData( ) ;
         this.CiudadSet.EnforceConstraints = tmpConstraintState ;
         if ( CiudadSet.Ciudad.Count > 0 )
         {
            rowCiudad = CiudadSet.Ciudad[CiudadSet.Ciudad.Count -1] ;
         }
      }

      private void AddRowCiudad( )
      {
         CiudadSet.Ciudad.AddCiudadRow( rowCiudad) ;
      }

      private readonly string m_SelectString6 = "TM1.[CiudadId], T2.[PaisNombre], T2.[PaisMoneda], TM1.[CiudadNombre], TM1.[PaisId]" ;


      public delegate  void CiudadUpdateEventHandler( object sender ,
                                                      CiudadEventArgs e );
      public event CiudadUpdateEventHandler CiudadUpdated ;
      private void OnCiudadUpdated( CiudadEventArgs e )
      {
         if ( this.CiudadUpdated != null )
         {
            this.CiudadUpdated( this, e) ;
         }
      }

      public event CiudadUpdateEventHandler CiudadUpdating ;
      private void OnCiudadUpdating( CiudadEventArgs e )
      {
         if ( this.CiudadUpdating != null )
         {
            this.CiudadUpdating( this, e) ;
         }
      }

      public class CiudadEventArgs : EventArgs
      {
         private System.Data.StatementType m_statementType ;
         private CiudadDataSet.CiudadRow m_dataRow ;
         public CiudadEventArgs( CiudadDataSet.CiudadRow row ,
                                 StatementType statementType )
         {
            m_dataRow = row ;
            m_statementType = statementType ;
         }

         public System.Data.StatementType StatementType
         {
            get {
               return m_statementType ;
            }

         }

         public CiudadDataSet.CiudadRow Row
         {
            get {
               return m_dataRow ;
            }

            set {
               m_dataRow = value ;
            }

         }

      }


      // Custom Exceptions
      [Serializable()]
      public class CiudadNotFoundException : Deklarit.DataNotFoundException
      {
         public CiudadNotFoundException( )
         {
         }

         public CiudadNotFoundException( string message ) : base(message)
         {
         }

         public CiudadNotFoundException( string message ,
                                         Exception inner ) : base(message, inner)
         {
         }

         protected CiudadNotFoundException( SerializationInfo info ,
                                            StreamingContext context ) : base(info, context)
         {
         }

      }

      [Serializable()]
      public class PaisForeignKeyNotFoundException : Deklarit.ForeignKeyNotFoundException
      {
         public PaisForeignKeyNotFoundException( )
         {
         }

         public PaisForeignKeyNotFoundException( string message ) : base(message)
         {
         }

         public PaisForeignKeyNotFoundException( string message ,
                                                 Exception inner ) : base(message, inner)
         {
         }

         protected PaisForeignKeyNotFoundException( SerializationInfo info ,
                                                    StreamingContext context ) : base(info, context)
         {
         }

      }

      [Serializable()]
      public class CiudadDataLockedException : Deklarit.DataLockedException
      {
         public CiudadDataLockedException( )
         {
         }

         public CiudadDataLockedException( string message ) : base(message)
         {
         }

         public CiudadDataLockedException( string message ,
                                           Exception inner ) : base(message, inner)
         {
         }

         protected CiudadDataLockedException( SerializationInfo info ,
                                              StreamingContext context ) : base(info, context)
         {
         }

      }

      [Serializable()]
      public class CiudadDataChangedException : Deklarit.DataChangedException
      {
         public CiudadDataChangedException( )
         {
         }

         public CiudadDataChangedException( string message ) : base(message)
         {
         }

         public CiudadDataChangedException( string message ,
                                            Exception inner ) : base(message, inner)
         {
         }

         protected CiudadDataChangedException( SerializationInfo info ,
                                               StreamingContext context ) : base(info, context)
         {
         }

      }

      [Serializable()]
      public class CiudadDuplicateKeyException : Deklarit.DuplicateKeyException
      {
         public CiudadDuplicateKeyException( )
         {
         }

         public CiudadDuplicateKeyException( string message ) : base(message)
         {
         }

         public CiudadDuplicateKeyException( string message ,
                                             Exception inner ) : base(message, inner)
         {
         }

         protected CiudadDuplicateKeyException( SerializationInfo info ,
                                                StreamingContext context ) : base(info, context)
         {
         }

      }


      protected void Cleanup( )
      {
         dsDefault.Dispose();
      }


      private void Initialize( )
      {
         resourceManager = Deklarit.Utils.ResourceManager.Instance ;
         resourceManagerTables = new System.Resources.ResourceManager( "Deklarit.Tables", System.Reflection.Assembly.GetExecutingAssembly()) ;
         scmdbuf = "" ;
         m__CiudadNombreOriginal = new object();
         m_WhereString = "" ;
         if ( this.Transaction == null )
         {
            this.Transaction = ((System.Data.IDbTransaction)(System.Threading.Thread.GetData(System.Threading.Thread.GetNamedDataSlot(DeklaritTransaction.TransactionSlotName)) ));
         }
      }

      private short RcdFound6 ;
      private short IsModified ;
      private int recordCount ;
      private String scmdbuf ;
      private String m_WhereString ;
      private bool _Gxremove ;
      private DataStore dsDefault ;
      private System.Resources.ResourceManager resourceManager ;
      private System.Resources.ResourceManager resourceManagerTables ;
      private ReadWriteConnection connDefault ;
      private ReadWriteCommand cmCIUDADSELECT1 ;
      private IDataReader CIUDADSELECT1 ;
      private ReadWriteCommand cmCIUDADSELECT2 ;
      private IDataReader CIUDADSELECT2 ;
      private object m__CiudadNombreOriginal ;
      private IDataReader CIUDADSELECT4 ;
      private ReadWriteCommand cmCIUDADSELECT5 ;
      private IDataReader CIUDADSELECT5 ;
      private System.Data.StatementType Gx_mode ;
      private System.Data.StatementType sMode6 ;
   }

   public class CiudadDataReader : System.IDisposable
   {
      public CiudadDataReader( )
      {
      }

      private void init_reader( )
      {
         this.Initialize( ) ;
         dsDefault = new DataStore( new SqlServer2005Handler( ), "System.Data.SqlClient", DeklaritModel.Configuration.ConnectionString, DeklaritTransaction.TransactionSlotName) ;
         m_Disposed = false ;
         m_Closed = true ;
      }

      private IDbTransaction daCurrentTransaction ;
      ///  <summary>
      ///   Gets or sets the Transaction object to be used  by  CiudadDataReaderDeklarit DataReaderclasses
      ///    to commit changes to the Database.
      ///  </summary>
      public IDbTransaction Transaction
      {
         get {
            return daCurrentTransaction ;
         }

         set {
            daCurrentTransaction = value ;
         }

      }

      public IDataReader Open( )
      {
         init_reader( ) ;
         m_Closed = false ;
         connDefault = dsDefault.GetReadWriteConnection( daCurrentTransaction) ;
         cmCIUDADSELECT6 = connDefault.GetCommand("SELECT TM1.[CiudadId], T2.[PaisNombre], T2.[PaisMoneda], TM1.[CiudadNombre], TM1.[PaisId] FROM ([Ciudad] TM1 LEFT JOIN [Pais] T2 ON T2.[PaisId] = TM1.[PaisId]) ORDER BY TM1.[PaisId], TM1.[CiudadId] ", false) ;
         CIUDADSELECT6 = cmCIUDADSELECT6.ExecuteReader(((daCurrentTransaction==null) ? Configuration.ReaderCommandBehavior : CommandBehavior.Default)) ;
         return CIUDADSELECT6 ;
      }

      public IDataReader OpenByPaisIdCiudadId( short paisId ,
                                               short ciudadId )
      {
         init_reader( ) ;
         m_Closed = false ;
         connDefault = dsDefault.GetReadWriteConnection( daCurrentTransaction) ;
         cmCIUDADSELECT6 = connDefault.GetCommand("SELECT TM1.[CiudadId], T2.[PaisNombre], T2.[PaisMoneda], TM1.[CiudadNombre], TM1.[PaisId] FROM ([Ciudad] TM1 LEFT JOIN [Pais] T2 ON T2.[PaisId] = TM1.[PaisId]) WHERE TM1.[PaisId] = @PaisId and TM1.[CiudadId] = @CiudadId ORDER BY TM1.[PaisId], TM1.[CiudadId] ", false) ;
         if ( cmCIUDADSELECT6.IDbCommand.Parameters.Count == 0 )
         {
            cmCIUDADSELECT6.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@PaisId", System.Data.DbType.Int16));
            cmCIUDADSELECT6.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@CiudadId", System.Data.DbType.Int16));
         }
         cmCIUDADSELECT6.SetParameter(0, paisId);
         cmCIUDADSELECT6.SetParameter(1, ciudadId);
         CIUDADSELECT6 = cmCIUDADSELECT6.ExecuteReader(((daCurrentTransaction==null) ? Configuration.ReaderCommandBehavior : CommandBehavior.Default)) ;
         return CIUDADSELECT6 ;
      }

      public IDataReader OpenByPaisId( short paisId )
      {
         init_reader( ) ;
         m_Closed = false ;
         connDefault = dsDefault.GetReadWriteConnection( daCurrentTransaction) ;
         cmCIUDADSELECT6 = connDefault.GetCommand("SELECT TM1.[CiudadId], T2.[PaisNombre], T2.[PaisMoneda], TM1.[CiudadNombre], TM1.[PaisId] FROM ([Ciudad] TM1 LEFT JOIN [Pais] T2 ON T2.[PaisId] = TM1.[PaisId]) WHERE TM1.[PaisId] = @PaisId ORDER BY TM1.[PaisId], TM1.[CiudadId] ", false) ;
         if ( cmCIUDADSELECT6.IDbCommand.Parameters.Count == 0 )
         {
            cmCIUDADSELECT6.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@PaisId", System.Data.DbType.Int16));
         }
         cmCIUDADSELECT6.SetParameter(0, paisId);
         CIUDADSELECT6 = cmCIUDADSELECT6.ExecuteReader(((daCurrentTransaction==null) ? Configuration.ReaderCommandBehavior : CommandBehavior.Default)) ;
         return CIUDADSELECT6 ;
      }

      public int DeleteByPaisId( short paisId )
      {
         init_reader( ) ;
         int intCount = 0 ;
         connDefault = dsDefault.GetReadWriteConnection( daCurrentTransaction) ;
         cmCIUDADDELETE2 = connDefault.GetCommand("DELETE FROM [Ciudad]  WHERE [PaisId] = @PaisId", false) ;
         if ( cmCIUDADDELETE2.IDbCommand.Parameters.Count == 0 )
         {
            cmCIUDADDELETE2.IDbCommand.Parameters.Add(  dsDefault.GetDbParameter( "@PaisId", System.Data.DbType.Int16));
         }
         // Using cursor CIUDADDELETE2
         cmCIUDADDELETE2.SetParameter(0, paisId);
         intCount = cmCIUDADDELETE2.ExecuteStmt() ;
         return intCount ;
      }

      public void Dispose( )
      {
         if ( ! m_Disposed )
         {
            m_Disposed = true ;
            try
            {
               if ( ! m_Closed && ( CIUDADSELECT6 != null ) )
               {
                  m_Closed = true ;
                  CIUDADSELECT6.Close();
               }
            }
            finally
            {
               try
               {
                  connDefault.Close();
               }
               finally
               {
                  this.Cleanup();
               }
            }
         }
      }

      public void Close( )
      {
         this.Dispose( ) ;
      }


      protected void Cleanup( )
      {
         dsDefault.Dispose();
      }


      private void Initialize( )
      {
         scmdbuf = "" ;
         if ( this.Transaction == null )
         {
            this.Transaction = ((System.Data.IDbTransaction)(System.Threading.Thread.GetData(System.Threading.Thread.GetNamedDataSlot(DeklaritTransaction.TransactionSlotName)) ));
         }
      }

      private String scmdbuf ;
      private bool m_Disposed ;
      private bool m_Closed ;
      private DataStore dsDefault ;
      private ReadWriteConnection connDefault ;
      private ReadWriteCommand cmCIUDADSELECT6 ;
      private IDataReader CIUDADSELECT6 ;
      private ReadWriteCommand cmCIUDADDELETE2 ;
   }

}
